home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / PPCToolbox.p < prev    next >
Text File  |  1996-05-01  |  18KB  |  496 lines
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Contains:    Program-Program Communications Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT PPCToolbox;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __PPCTOOLBOX__}
  28. {$SETC __PPCTOOLBOX__ := 1}
  29.  
  30. {$I+}
  31. {$SETC PPCToolboxIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __APPLETALK__}
  35. {$I AppleTalk.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MEMORY__}
  38. {$I Memory.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __TYPES__}
  41. {$I Types.p}
  42. {$ENDC}
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  49.  
  50. TYPE
  51.     PPCServiceType                        = UInt8;
  52.  
  53. CONST
  54.     ppcServiceRealTime            = 1;
  55.  
  56.  
  57. TYPE
  58.     PPCLocationKind                        = INTEGER;
  59.  
  60. CONST
  61.     ppcNoLocation                = 0;                            {  There is no PPCLocName  }
  62.     ppcNBPLocation                = 1;                            {  Use AppleTalk NBP       }
  63.     ppcNBPTypeLocation            = 2;                            {  Used for specifying a location name type during PPCOpen only  }
  64.  
  65.  
  66. TYPE
  67.     PPCPortKinds                        = INTEGER;
  68.  
  69. CONST
  70.     ppcByCreatorAndType            = 1;                            {  Port type is specified as colloquial Mac creator and type  }
  71.     ppcByString                    = 2;                            {  Port type is in pascal string format  }
  72.  
  73. {  Values returned for request field in PPCInform call  }
  74.  
  75. TYPE
  76.     PPCSessionOrigin                    = UInt8;
  77.  
  78. CONST
  79.                                                                 {  Values returned for requestType field in PPCInform call  }
  80.     ppcLocalOrigin                = 1;                            {  session originated from this machine  }
  81.     ppcRemoteOrigin                = 2;                            {  session originated from remote machine  }
  82.  
  83.  
  84. TYPE
  85.     PPCPortRefNum                        = INTEGER;
  86.     PPCSessRefNum                        = LONGINT;
  87.     PPCPortRecPtr = ^PPCPortRec;
  88.     PPCPortRec = RECORD
  89.         nameScript:                ScriptCode;                                {  script of name  }
  90.         name:                    Str32Field;                                {  name of port as seen in browser  }
  91.         portKindSelector:        PPCPortKinds;                            {  which variant  }
  92.         CASE INTEGER OF
  93.         0: (
  94.             portTypeStr:        Str32;                                    {  pascal type string  }
  95.             );
  96.         1: (
  97.             portCreator:        OSType;
  98.             portType:            OSType;
  99.            );
  100.     END;
  101.  
  102.     PPCPortPtr                            = ^PPCPortRec;
  103.     LocationNameRecPtr = ^LocationNameRec;
  104.     LocationNameRec = RECORD
  105.         locationKindSelector:    PPCLocationKind;                        {  which variant  }
  106.         CASE INTEGER OF
  107.         0: (
  108.             nbpEntity:            EntityName;                                {  NBP name entity  }
  109.             );
  110.         1: (
  111.             nbpType:            Str32;                                    {  just the NBP type string, for PPCOpen  }
  112.             );
  113.     END;
  114.  
  115.     LocationNamePtr                        = ^LocationNameRec;
  116.     PortInfoRecPtr = ^PortInfoRec;
  117.     PortInfoRec = RECORD
  118.         filler1:                SInt8;
  119.         authRequired:            BOOLEAN;
  120.         name:                    PPCPortRec;
  121.     END;
  122.  
  123.     PortInfoPtr                            = ^PortInfoRec;
  124.     PortInfoArrayPtr                    = ^PortInfoRec;
  125.     PPCParamBlockRecPtr = ^PPCParamBlockRec;
  126.     PPCParamBlockPtr                    = ^PPCParamBlockRec;
  127.     PPCCompProcPtr = ProcPtr;  { PROCEDURE PPCComp(pb: PPCParamBlockPtr); }
  128.  
  129.     PPCCompUPP = UniversalProcPtr;
  130.     PPCOpenPBRecPtr = ^PPCOpenPBRec;
  131.     PPCOpenPBRec = PACKED RECORD
  132.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  133.         csCode:                    INTEGER;                                {  Requested PPC command  }
  134.         intUse:                    INTEGER;                                {  Internal Use  }
  135.         intUsePtr:                Ptr;                                    {  Internal Use  }
  136.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  137.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  138.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  139.         portRefNum:                PPCPortRefNum;                            {  38 <--   Port Reference  }
  140.         filler1:                LONGINT;
  141.         serviceType:            PPCServiceType;                            {  44 -->    Bit field describing the requested port service  }
  142.         resFlag:                UInt8;                                    {  Must be set to 0  }
  143.         portName:                PPCPortPtr;                                {  46 -->   PortName for PPC  }
  144.         locationName:            LocationNamePtr;                        {  50 -->   If NBP Registration is required  }
  145.         networkVisible:            BOOLEAN;                                {  54 -->   make this network visible on network  }
  146.         nbpRegistered:            BOOLEAN;                                {  55 <--   The given location name was registered on the network  }
  147.     END;
  148.  
  149.     PPCOpenPBPtr                        = ^PPCOpenPBRec;
  150.     PPCInformPBRecPtr = ^PPCInformPBRec;
  151.     PPCInformPBRec = PACKED RECORD
  152.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  153.         csCode:                    INTEGER;                                {  Requested PPC command  }
  154.         intUse:                    INTEGER;                                {  Internal Use  }
  155.         intUsePtr:                Ptr;                                    {  Internal Use  }
  156.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  157.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  158.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  159.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  160.         sessRefNum:                PPCSessRefNum;                            {  40 <--   Session Reference  }
  161.         serviceType:            PPCServiceType;                            {  44 <--   Status Flags for type of session, local, remote  }
  162.         autoAccept:                BOOLEAN;                                {  45 -->   if true session will be accepted automatically  }
  163.         portName:                PPCPortPtr;                                {  46 -->   Buffer for Source PPCPortRec  }
  164.         locationName:            LocationNamePtr;                        {  50 -->   Buffer for Source LocationNameRec  }
  165.         userName:                StringPtr;                                {  54 -->   Buffer for Soure user's name trying to link.  }
  166.         userData:                LONGINT;                                {  58 <--   value included in PPCStart's userData  }
  167.         requestType:            PPCSessionOrigin;                        {  62 <--   Local or Network  }
  168.         filler:                    SInt8;
  169.     END;
  170.  
  171.     PPCInformPBPtr                        = ^PPCInformPBRec;
  172.     PPCStartPBRecPtr = ^PPCStartPBRec;
  173.     PPCStartPBRec = PACKED RECORD
  174.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  175.         csCode:                    INTEGER;                                {  Requested PPC command  }
  176.         intUse:                    INTEGER;                                {  Internal Use  }
  177.         intUsePtr:                Ptr;                                    {  Internal Use  }
  178.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  179.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  180.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  181.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  182.         sessRefNum:                PPCSessRefNum;                            {  40 <--   Session Reference  }
  183.         serviceType:            PPCServiceType;                            {  44 <--   Actual service method (realTime)  }
  184.         resFlag:                UInt8;                                    {  45 -->   Must be set to 0   }
  185.         portName:                PPCPortPtr;                                {  46 -->   Destination portName  }
  186.         locationName:            LocationNamePtr;                        {  50 -->   NBP or NAS style service location name  }
  187.         rejectInfo:                LONGINT;                                {  54 <--   reason for rejecting the session request  }
  188.         userData:                LONGINT;                                {  58 -->   Copied to destination PPCInform parameter block  }
  189.         userRefNum:                LONGINT;                                {  62 -->   userRefNum (obtained during login process)   }
  190.     END;
  191.  
  192.     PPCStartPBPtr                        = ^PPCStartPBRec;
  193.     PPCAcceptPBRecPtr = ^PPCAcceptPBRec;
  194.     PPCAcceptPBRec = RECORD
  195.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  196.         csCode:                    INTEGER;                                {  Requested PPC command  }
  197.         intUse:                    INTEGER;                                {  Internal Use  }
  198.         intUsePtr:                Ptr;                                    {  Internal Use  }
  199.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  200.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  201.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  202.         filler1:                INTEGER;
  203.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  204.     END;
  205.  
  206.     PPCAcceptPBPtr                        = ^PPCAcceptPBRec;
  207.     PPCRejectPBRecPtr = ^PPCRejectPBRec;
  208.     PPCRejectPBRec = RECORD
  209.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  210.         csCode:                    INTEGER;                                {  Requested PPC command  }
  211.         intUse:                    INTEGER;                                {  Internal Use  }
  212.         intUsePtr:                Ptr;                                    {  Internal Use  }
  213.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  214.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  215.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  216.         filler1:                INTEGER;
  217.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  218.         filler2:                INTEGER;
  219.         filler3:                LONGINT;
  220.         filler4:                LONGINT;
  221.         rejectInfo:                LONGINT;                                {  54 -->   reason for rejecting the session request   }
  222.     END;
  223.  
  224.     PPCRejectPBPtr                        = ^PPCRejectPBRec;
  225.     PPCWritePBRecPtr = ^PPCWritePBRec;
  226.     PPCWritePBRec = RECORD
  227.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  228.         csCode:                    INTEGER;                                {  Requested PPC command  }
  229.         intUse:                    INTEGER;                                {  Internal Use  }
  230.         intUsePtr:                Ptr;                                    {  Internal Use  }
  231.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  232.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  233.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  234.         filler1:                INTEGER;
  235.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  236.         bufferLength:            Size;                                    {  44 -->   Length of the message buffer  }
  237.         actualLength:            Size;                                    {  48 <--   Actual Length Written  }
  238.         bufferPtr:                Ptr;                                    {  52 -->   Pointer to message buffer  }
  239.         more:                    BOOLEAN;                                {  56 -->   if more data in this block will be written  }
  240.         filler2:                SInt8;
  241.         userData:                LONGINT;                                {  58 -->   Message block userData Uninterpreted by PPC  }
  242.         blockCreator:            OSType;                                    {  62 -->   Message block creator Uninterpreted by PPC  }
  243.         blockType:                OSType;                                    {  66 -->   Message block type Uninterpreted by PPC  }
  244.     END;
  245.  
  246.     PPCWritePBPtr                        = ^PPCWritePBRec;
  247.     PPCReadPBRecPtr = ^PPCReadPBRec;
  248.     PPCReadPBRec = RECORD
  249.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  250.         csCode:                    INTEGER;                                {  Requested PPC command  }
  251.         intUse:                    INTEGER;                                {  Internal Use  }
  252.         intUsePtr:                Ptr;                                    {  Internal Use  }
  253.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  254.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  255.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  256.         filler1:                INTEGER;
  257.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  258.         bufferLength:            Size;                                    {  44 -->   Length of the message buffer  }
  259.         actualLength:            Size;                                    {  48 <--   Actual length read  }
  260.         bufferPtr:                Ptr;                                    {  52 -->   Pointer to message buffer  }
  261.         more:                    BOOLEAN;                                {  56 <--   if true more data in this block to be read  }
  262.         filler2:                SInt8;
  263.         userData:                LONGINT;                                {  58 <--   Message block userData Uninterpreted by PPC  }
  264.         blockCreator:            OSType;                                    {  62 <--   Message block creator Uninterpreted by PPC  }
  265.         blockType:                OSType;                                    {  66 <--   Message block type Uninterpreted by PPC  }
  266.     END;
  267.  
  268.     PPCReadPBPtr                        = ^PPCReadPBRec;
  269.     PPCEndPBRecPtr = ^PPCEndPBRec;
  270.     PPCEndPBRec = RECORD
  271.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  272.         csCode:                    INTEGER;                                {  Requested PPC command  }
  273.         intUse:                    INTEGER;                                {  Internal Use  }
  274.         intUsePtr:                Ptr;                                    {  Internal Use  }
  275.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  276.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  277.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  278.         filler1:                INTEGER;
  279.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  280.     END;
  281.  
  282.     PPCEndPBPtr                            = ^PPCEndPBRec;
  283.     PPCClosePBRecPtr = ^PPCClosePBRec;
  284.     PPCClosePBRec = RECORD
  285.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  286.         csCode:                    INTEGER;                                {  Requested PPC command  }
  287.         intUse:                    INTEGER;                                {  Internal Use  }
  288.         intUsePtr:                Ptr;                                    {  Internal Use  }
  289.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  290.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  291.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  292.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  293.     END;
  294.  
  295.     PPCClosePBPtr                        = ^PPCClosePBRec;
  296.     IPCListPortsPBRecPtr = ^IPCListPortsPBRec;
  297.     IPCListPortsPBRec = RECORD
  298.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  299.         csCode:                    INTEGER;                                {  Requested PPC command  }
  300.         intUse:                    INTEGER;                                {  Internal Use  }
  301.         intUsePtr:                Ptr;                                    {  Internal Use  }
  302.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  303.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  304.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  305.         filler1:                INTEGER;
  306.         startIndex:                INTEGER;                                {  40 -->   Start Index  }
  307.         requestCount:            INTEGER;                                {  42 -->   Number of entries to be returned  }
  308.         actualCount:            INTEGER;                                {  44 <--   Actual Number of entries to be returned  }
  309.         portName:                PPCPortPtr;                                {  46 -->   PortName Match  }
  310.         locationName:            LocationNamePtr;                        {  50 -->   NBP or NAS type name to locate the Port Location  }
  311.         bufferPtr:                PortInfoArrayPtr;                        {  54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big  }
  312.     END;
  313.  
  314.     IPCListPortsPBPtr                    = ^IPCListPortsPBRec;
  315.     PPCParamBlockRec = RECORD
  316.         CASE INTEGER OF
  317.         0: (
  318.             openParam:            PPCOpenPBRec;
  319.             );
  320.         1: (
  321.             informParam:        PPCInformPBRec;
  322.             );
  323.         2: (
  324.             startParam:            PPCStartPBRec;
  325.             );
  326.         3: (
  327.             acceptParam:        PPCAcceptPBRec;
  328.             );
  329.         4: (
  330.             rejectParam:        PPCRejectPBRec;
  331.             );
  332.         5: (
  333.             writeParam:            PPCWritePBRec;
  334.             );
  335.         6: (
  336.             readParam:            PPCReadPBRec;
  337.             );
  338.         7: (
  339.             endParam:            PPCEndPBRec;
  340.             );
  341.         8: (
  342.             closeParam:            PPCClosePBRec;
  343.             );
  344.         9: (
  345.             listPortsParam:        IPCListPortsPBRec;
  346.             );
  347.     END;
  348.  
  349. {   PPC Calling Conventions   }
  350. FUNCTION PPCInit: OSErr;
  351.     {$IFC NOT GENERATINGCFM}
  352.     INLINE $7000, $A0DD, $3E80;
  353.     {$ENDC}
  354. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $205F, $7001, $A0DD, $3E80;
  357.     {$ENDC}
  358. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  359.     {$IFC NOT GENERATINGCFM}
  360.     INLINE $205F, $7001, $A4DD, $3E80;
  361.     {$ENDC}
  362. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  363.     {$IFC NOT GENERATINGCFM}
  364.     INLINE $205F, $7003, $A0DD, $3E80;
  365.     {$ENDC}
  366. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $205F, $7003, $A4DD, $3E80;
  369.     {$ENDC}
  370. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  371.     {$IFC NOT GENERATINGCFM}
  372.     INLINE $205F, $7002, $A0DD, $3E80;
  373.     {$ENDC}
  374. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  375.     {$IFC NOT GENERATINGCFM}
  376.     INLINE $205F, $7002, $A4DD, $3E80;
  377.     {$ENDC}
  378. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  379.     {$IFC NOT GENERATINGCFM}
  380.     INLINE $205F, $7004, $A0DD, $3E80;
  381.     {$ENDC}
  382. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $205F, $7004, $A4DD, $3E80;
  385.     {$ENDC}
  386. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  387.     {$IFC NOT GENERATINGCFM}
  388.     INLINE $205F, $7005, $A0DD, $3E80;
  389.     {$ENDC}
  390. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $205F, $7005, $A4DD, $3E80;
  393.     {$ENDC}
  394. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  395.     {$IFC NOT GENERATINGCFM}
  396.     INLINE $205F, $7006, $A0DD, $3E80;
  397.     {$ENDC}
  398. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $205F, $7006, $A4DD, $3E80;
  401.     {$ENDC}
  402. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  403.     {$IFC NOT GENERATINGCFM}
  404.     INLINE $205F, $7007, $A0DD, $3E80;
  405.     {$ENDC}
  406. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  407.     {$IFC NOT GENERATINGCFM}
  408.     INLINE $205F, $7007, $A4DD, $3E80;
  409.     {$ENDC}
  410. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  411.     {$IFC NOT GENERATINGCFM}
  412.     INLINE $205F, $7008, $A0DD, $3E80;
  413.     {$ENDC}
  414. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  415.     {$IFC NOT GENERATINGCFM}
  416.     INLINE $205F, $7008, $A4DD, $3E80;
  417.     {$ENDC}
  418. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $205F, $7009, $A0DD, $3E80;
  421.     {$ENDC}
  422. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $205F, $7009, $A4DD, $3E80;
  425.     {$ENDC}
  426. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $205F, $700A, $A0DD, $3E80;
  429.     {$ENDC}
  430. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  431.     {$IFC NOT GENERATINGCFM}
  432.     INLINE $205F, $700A, $A4DD, $3E80;
  433.     {$ENDC}
  434. FUNCTION DeleteUserIdentity(userRef: LONGINT): OSErr;
  435. FUNCTION GetDefaultUser(VAR userRef: LONGINT; VAR userName: Str32): OSErr;
  436. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: Str255): OSErr;
  437.  
  438. TYPE
  439.     PPCFilterProcPtr = ProcPtr;  { FUNCTION PPCFilter(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN; }
  440.  
  441.     PPCFilterUPP = UniversalProcPtr;
  442.  
  443. CONST
  444.     uppPPCCompProcInfo = $000000C0;
  445.     uppPPCFilterProcInfo = $000003D0;
  446.  
  447. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  448.     {$IFC NOT GENERATINGCFM }
  449.     INLINE $2E9F;
  450.     {$ENDC}
  451.  
  452. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  453.     {$IFC NOT GENERATINGCFM }
  454.     INLINE $2E9F;
  455.     {$ENDC}
  456.  
  457. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  458.     {$IFC NOT GENERATINGCFM}
  459.     INLINE $205F, $4E90;
  460.     {$ENDC}
  461.  
  462. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  463.     {$IFC NOT GENERATINGCFM}
  464.     INLINE $205F, $4E90;
  465.     {$ENDC}
  466. FUNCTION PPCBrowser(prompt: Str255; applListLabel: Str255; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: Str32): OSErr;
  467.     {$IFC NOT GENERATINGCFM}
  468.     INLINE $303C, $0D00, $A82B;
  469.     {$ENDC}
  470. {$IFC OLDROUTINENAMES }
  471. {
  472.   The ParamBlock calls with the "Sync" or "Async" suffix are being phased out.
  473. }
  474. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  475. FUNCTION PPCInform(pb: PPCInformPBPtr; async: BOOLEAN): OSErr;
  476. FUNCTION PPCStart(pb: PPCStartPBPtr; async: BOOLEAN): OSErr;
  477. FUNCTION PPCAccept(pb: PPCAcceptPBPtr; async: BOOLEAN): OSErr;
  478. FUNCTION PPCReject(pb: PPCRejectPBPtr; async: BOOLEAN): OSErr;
  479. FUNCTION PPCWrite(pb: PPCWritePBPtr; async: BOOLEAN): OSErr;
  480. FUNCTION PPCRead(pb: PPCReadPBPtr; async: BOOLEAN): OSErr;
  481. FUNCTION PPCEnd(pb: PPCEndPBPtr; async: BOOLEAN): OSErr;
  482. FUNCTION PPCClose(pb: PPCClosePBPtr; async: BOOLEAN): OSErr;
  483. FUNCTION IPCListPorts(pb: IPCListPortsPBPtr; async: BOOLEAN): OSErr;
  484. {$ENDC}
  485. {$ENDC}
  486. {$ALIGN RESET}
  487. {$POP}
  488.  
  489. {$SETC UsingIncludes := PPCToolboxIncludes}
  490.  
  491. {$ENDC} {__PPCTOOLBOX__}
  492.  
  493. {$IFC NOT UsingIncludes}
  494.  END.
  495. {$ENDC}
  496.